home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 April: Mac OS SDK / Dev.CD Apr 97 SDK1.toast / Development Kits (Disc 1) / Macintosh Easy Open / Documentation / Developer / PowerPC / LowerToUpperCase.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-09-11  |  18.9 KB  |  605 lines  |  [TEXT/MPS ]
  1. /*
  2.     File:         LowerToUpperCase.c 
  3.  
  4.     Contains:    Source to a FAT extension translator that converts from lower to upper case
  5.                 The source type is always 'TEXT' and the destination type is 'UPPR'.
  6.     
  7.     Copyright:    © 1994 by Apple Computer, Inc., all rights reserved.
  8.     
  9.     
  10.     Modified from LowerToUpperCaseScrap example. Filled in the file translation part.
  11.     R.Silva         9/11/95
  12. */
  13.  
  14. #include <Types.h>
  15. #include <Files.h>
  16. #include <MixedMode.h>
  17. #include <Traps.h>
  18. #include <Errors.h>
  19. #include <Memory.h>
  20. #include <Resources.h>
  21. #include <Components.h>
  22. #include <TranslationExtensions.h>
  23. #include "LowerToUpperCase.h"
  24.  
  25. //___________________________________________________________________________________________________________
  26. //
  27. // Structures
  28. //
  29.  
  30. // Our magic cookie to tell if our translation list is initialized or not
  31. #define kModificationDateMagicCookie    0x00000001
  32.  
  33. // Set up a fixed scrap translation list structure for easy access
  34. #if defined(powerc) || defined (__powerc)
  35. #pragma options align=mac68k
  36. #endif
  37. struct OurScrapTranslationList
  38. {
  39.     unsigned long    modDate;
  40.     unsigned long    groupCount;
  41.     unsigned long    sourceCount;
  42.     unsigned long    sourceEntrySize;
  43.     ScrapTypeSpec    sourceType;
  44.     unsigned long    destinationCount;
  45.     unsigned long    destinationEntrySize;
  46.     ScrapTypeSpec    desinationType;
  47. };
  48. #if defined(powerc) || defined(__powerc)
  49. #pragma options align=reset
  50. #endif
  51.  
  52. typedef struct OurScrapTranslationList OurScrapTranslationList;
  53. typedef OurScrapTranslationList *OurScrapTranslationListPtr, **OurScrapTranslationListHandle;
  54.  
  55.  
  56. // Set up a fixed file translation list structure for easy access
  57. #if defined(powerc) || defined (__powerc)
  58. #pragma options align=mac68k
  59. #endif
  60. struct OurFileTranslationList
  61. {
  62.     unsigned long    modDate;
  63.     unsigned long    groupCount;
  64.     unsigned long    sourceCount;
  65.     unsigned long    sourceEntrySize;
  66.     FileTypeSpec    sourceType;
  67.     unsigned long    destinationCount;
  68.     unsigned long    destinationEntrySize;
  69.     FileTypeSpec    desinationType;
  70. };
  71. #if defined(powerc) || defined(__powerc)
  72. #pragma options align=reset
  73. #endif
  74.  
  75. typedef struct OurFileTranslationList OurFileTranslationList;
  76. typedef OurFileTranslationList *OurFileTranslationListPtr, **OurFileTranslationListHandle;
  77.  
  78.  
  79.  
  80. //___________________________________________________________________________________________________________
  81. //
  82. // DoGetScrapTranslationList
  83. //
  84. // This routine is called by the Translation Manager when it needs to find out what formats the scrap
  85. // translator translates between.
  86. //
  87. // Enter:    self    Instance of this translator
  88. //            list    Handle to scrap translation list provided by this translator earlier, or empty handle
  89. //                    if never set before
  90. //
  91. // Exit:    list    Handle to scrap translation list filled in my this routine
  92. //            returns    Any errors that might occur
  93. //
  94. pascal ComponentResult DoGetScrapTranslationList(ComponentInstance             self, 
  95.                                                  ScrapTranslationListHandle    list)
  96. {
  97. #pragma unused(self)
  98.     OurScrapTranslationListHandle    ourList = (OurScrapTranslationListHandle) list;        // Easier to reference
  99.     OSErr                        result = noErr;
  100.  
  101.     // The list never changes here - so see if it's been initialized once by looking
  102.     // for our magic cookie
  103.     if (((*ourList)->modDate) != kModificationDateMagicCookie){
  104.         // Resize the handle to fit our entry
  105.         SetHandleSize((Handle)ourList, sizeof(OurScrapTranslationList));
  106.         if ((result = MemError()) == noErr) {
  107.             // Stuff all the values into our fixed list
  108.             (*ourList)->modDate = kModificationDateMagicCookie;                    // Magic cookie
  109.             (*ourList)->groupCount = 1;                                            // Number groups = 1
  110.             (*ourList)->sourceCount = 1;                                        // Only 1 source type
  111.             (*ourList)->sourceEntrySize = sizeof(ScrapTypeSpec);                // Currently always sizeof(ScrapTypeSpec)
  112.             (*ourList)->sourceType.format = 'TEXT';                                // Source type is always 'TEXT'
  113.             (*ourList)->sourceType.hint = 0;                                    // Don't care about this
  114.             (*ourList)->destinationCount = 1;                                    // Only 1 destination type
  115.             (*ourList)->destinationEntrySize = sizeof(ScrapTypeSpec);            // Currently always sizeof(ScrapTypeSpec)
  116.             (*ourList)->desinationType.format = 'UPPR';                            // Destination type is always 'UPPR'
  117.             (*ourList)->desinationType.hint = 0;                                // Don't care about this
  118.         }        
  119.     }
  120.         
  121.     return result;
  122. }
  123.  
  124. //___________________________________________________________________________________________________________
  125. //
  126. // DoIdentifyScrap
  127. //
  128. // This routine is called to identify a scraps contents.  In this case, just check to see if the scrap
  129. // is type TEXT, and if it is, then we know it's TEXT.
  130. //
  131. // Enter:    self        Instance of this translator
  132. //            dataPtr        Pointer to data to identify
  133. //            dataLength    Size of data referenced by dataPtr
  134. //            dataFormat    Provided format for the data referenced by dataPtr
  135. //
  136. // Exit:    dataFormat    Changed format (if applicable)
  137. //            returns        noErr is scrap contents are TEXT, otherwise noTypeErr
  138. //
  139. pascal ComponentResult DoIdentifyScrap(ComponentInstance    self, 
  140.                                        const void*             dataPtr, 
  141.                                        Size                 dataLength, 
  142.                                        ScrapType*             dataFormat)
  143. {
  144. #pragma unused(self)
  145. #pragma unused(dataPtr)
  146. #pragma unused(dataLength)
  147.     OSErr    result = noErr;
  148.     
  149.     // We only know TEXT.  See if the format is that.  If it isn't then we don't translate
  150.     if (*dataFormat != 'TEXT')
  151.         result = noTypeErr;
  152.  
  153.     return result;
  154. }
  155.  
  156. //___________________________________________________________________________________________________________
  157. //
  158. // DoTranslateScrap
  159. //
  160. // This routine is called to perform a scrap translation.  It is only called if the source type is TEXT and
  161. // if DoIdentifyScrap was called as was able to confirm that.  Also, it is only called if the destination type
  162. // is UPPR.
  163. //
  164. // This specific translation converts all lower case characters to upper case.  Leaves the rest alone.
  165. //
  166. // Enter:    self            Instance of this translator
  167. //            progressRefNum    Reference number to progress dialog
  168. //            srcDataPtr        Pointer to source data
  169. //            srcDataLength    Length of data pointed to by srcDataPtr
  170. //            srcType            Type of data pointed to by srcDataPtr (provided via DoIdentifyScrap)
  171. //            srcTypeHint        Hint for data pointed to by srcDataPtr (from ScrapTranslationList)
  172. //            dstData            Handle to place translated destination data into
  173. //            dstType            Type of data to translate srcDataPtr into
  174. //            dstTypeHint        Hint for data to translate to (from ScrapTranslationList)
  175. //
  176. // Exit:    dstData            Handle resized and filled in with translated contents
  177. //            returns            Any errors that might occur.
  178. //            
  179. pascal ComponentResult DoTranslateScrap(ComponentInstance     self, 
  180.                                         TranslationRefNum     progressRefNum,
  181.                                         const void*            srcDataPtr, 
  182.                                         Size                 srcDataLength, 
  183.                                         ScrapType             srcType, 
  184.                                         long                 srcTypeHint,
  185.                                         Handle                 dstData, 
  186.                                         ScrapType             dstType, 
  187.                                         long                 dstTypeHint)
  188. {
  189. #pragma unused(self)
  190. #pragma unused(srcType)
  191. #pragma unused(srcTypeHint)
  192. #pragma unused(dstType)
  193. #pragma unused(dstTypeHint)
  194.  
  195.     OSErr    result;
  196.     char*    currentCharacter;
  197.     char*    lastCharacter;
  198.     char*    writeCharacter;
  199.     short    count;
  200.     Boolean    canceled = false;
  201.     short    myShort;
  202.     Handle  myAdvert;
  203.     OSErr    myErr;
  204.     
  205.     myShort = OpenComponentResFile((Component)self);
  206.     myAdvert = Get1Resource('PICT', kProgressAdvertisement);
  207.     if(myAdvert != nil){
  208.         DetachResource(myAdvert);
  209.         SetTranslationAdvertisement(progressRefNum,(PicHandle) myAdvert);
  210.     }
  211.     else {
  212.         SetTranslationAdvertisement(progressRefNum, nil);
  213.     }
  214.     myErr = CloseComponentResFile(myShort);
  215.     
  216.     // Resize the destination handle to fit all the translated contents
  217.     SetHandleSize(dstData, srcDataLength);
  218.     if ((result = MemError()) == noErr)
  219.         {
  220.         // Give me a pointer to the first character and the last character in the source buffer
  221.         currentCharacter = (char*) srcDataPtr;
  222.         lastCharacter = currentCharacter + srcDataLength;
  223.         
  224.         // Give me a pointer to the first character in the destination buffer
  225.         // (lock it down first because stupid update may move memory)
  226.         HLock(dstData);
  227.         writeCharacter = (char *)*dstData;
  228.         
  229.         // Keep a count for the progress dialog
  230.         count = 0;
  231.         
  232.         // Loop through each of the characters in the buffer
  233.         while ((currentCharacter <= lastCharacter) && !canceled)
  234.             {
  235.             // Are we in the lower case ASCII range?
  236.             if (('a' <= *currentCharacter) && (*currentCharacter <= 'z'))
  237.                 {
  238.                 *writeCharacter = (*currentCharacter - ('a' - 'A'));
  239.                 }
  240.             else
  241.                 *writeCharacter = *currentCharacter;
  242.             
  243.             // Increment the progress bar
  244.             UpdateTranslationProgress(progressRefNum, ++count * (100.00 / srcDataLength), &canceled);
  245.             
  246.             // Next…
  247.             currentCharacter++;
  248.             writeCharacter++;
  249.             }
  250.             
  251.         // Let it wiggle, see it squiggle
  252.         HUnlock(dstData);
  253.         }
  254.     
  255.     return result;
  256. }
  257.  
  258. //___________________________________________________________________________________________________________
  259. //
  260. // DoGetFileTranslationList
  261. //
  262. // This routine is called by the Translation Manager when it needs to find out what formats the scrap
  263. // translator translates between.
  264. //
  265. // Enter:    self    Instance of this translator
  266. //            list    Handle to file translation list provided by this translator earlier, or empty handle
  267. //                    if never set before
  268. //
  269. // Exit:    list    Handle to file translation list filled in my this routine
  270. //            returns    Any errors that might occur
  271. // 
  272. //
  273. pascal ComponentResult DoGetFileTranslationList(ComponentInstance             self, 
  274.                                                 FileTranslationListHandle    list)
  275. {
  276. #pragma unused(self)        
  277. #pragma unused(translationList)        
  278.  
  279.     OurFileTranslationListHandle    ourList = (OurFileTranslationListHandle) list;        // Easier to reference
  280.     OSErr                        result = noErr;
  281.  
  282.     // The list never changes here - so see if it's been initialized once by looking
  283.     // for our magic cookie
  284.     if (((*ourList)->modDate) != kModificationDateMagicCookie){
  285.         // Resize the handle to fit our entry
  286.         SetHandleSize((Handle)ourList, sizeof(OurFileTranslationList));
  287.         if ((result = MemError()) == noErr) {
  288.             // Stuff all the values into our fixed list
  289.             (*ourList)->modDate = kModificationDateMagicCookie;                    // Magic cookie
  290.             (*ourList)->groupCount = 1;                                            // Number groups = 1
  291.             (*ourList)->sourceCount = 1;                                        // Only 1 source type
  292.             (*ourList)->sourceEntrySize = sizeof(FileTypeSpec);                    // Currently always sizeof(FileTypeSpec)
  293.             (*ourList)->sourceType.format = 'TEXT';                                // Source type is always 'TEXT'
  294.             (*ourList)->sourceType.hint = 0;                                    // Don't care about this
  295.             (*ourList)->sourceType.flags = 0;
  296.             (*ourList)->sourceType.catInfoType = 'TEXT';
  297.             (*ourList)->sourceType.catInfoCreator = 'ttxt';
  298.             (*ourList)->destinationCount = 1;                                    // Only 1 destination type
  299.             (*ourList)->destinationEntrySize = sizeof(FileTypeSpec);            // Currently always sizeof(FileTypeSpec)
  300.             (*ourList)->desinationType.format = 'UPPR';                            // Destination type is always 'UPPR'
  301.             (*ourList)->desinationType.hint = 0;                                // Don't care about this
  302.             (*ourList)->desinationType.flags = 0;
  303.             (*ourList)->desinationType.catInfoType = 'UPPR';
  304.             (*ourList)->desinationType.catInfoCreator = 'PPd√';                    //??
  305.         }        
  306.     }
  307.         
  308.     return result;
  309. }
  310.  
  311. //___________________________________________________________________________________________________________
  312. //
  313. // DoIdentifyFile
  314. //
  315. // This routine is called to identify a file by its contents.  
  316. // Here we simply decide the fileType is 'TEXT'.
  317. //
  318. // Enter:    self        Instance of this translator
  319. //            theDoc        file FSSpec
  320. //
  321. // Exit:    docKind        the fileType we decided it was
  322. //            returns        noErr 
  323. //
  324. //
  325. pascal ComponentResult DoIdentifyFile(ComponentInstance self, const FSSpec *theDoc, FileType *docKind)
  326. {
  327. #pragma unused(self)
  328. #pragma unused(theDoc)
  329. #pragma unused(docKind)
  330.     OSErr myErr = noErr;
  331.     
  332.     //not doing too much here
  333.     
  334.     *docKind = 'TEXT';
  335.     
  336.     return myErr;
  337. }
  338.  
  339. //___________________________________________________________________________________________________________
  340. //
  341. // DoTranslateFile
  342. //
  343. // This routine is called to perform a file translation.  It is only called if the file type is TEXT and
  344. // if DoIdentifyFile was called as was able to confirm that.  Also, it is only called if the destination type
  345. // is UPPR.
  346. //
  347. // This specific translation converts all lower case characters to upper case.  Leaves the rest alone.
  348. //
  349. // Enter:    self            Instance of this translator
  350. //            progressRefNum    Reference number to progress dialog
  351. //            srcDoc            Pointer to source file
  352. //            srcType            fileType provided from the DoIdentifyFile
  353. //            srcTypeHint        Hint for fileType pointed to by srcDoc (from GetTranslationList)
  354. //            dstDoc            Pointer to destination file spec
  355. //            dstType            file Type of destination file
  356. //            dstTypeHint        Hint for fileType to translate to (from GetTranslationList)
  357. //
  358. // Exit:    dstDoc            File is filled in with translation of data in source file
  359. //            returns            Any errors that might occur.
  360. //            
  361. //
  362. pascal ComponentResult DoTranslateFile(ComponentInstance self, TranslationRefNum progressRefNum,
  363.                                             const FSSpec* srcDoc, FileType srcType, long srcTypeHint, 
  364.                                             const FSSpec* dstDoc, FileType dstType, long dstTypeHint)
  365. { 
  366. #pragma unused(self)                        
  367. #pragma unused(progressRefNum)
  368. #pragma unused(srcDoc)
  369. #pragma unused(srcType)
  370. #pragma unused(srcTypeHint)
  371. #pragma unused(dstDoc)
  372. #pragma unused(dstType)
  373. #pragma unused(dstTypeHint)
  374.  
  375.     OSErr     myErr = noErr;
  376.     short    srcRefNum, dstRefNum;
  377.     char    copyBuffer[512];
  378.     long    copyBufferSize;
  379.     Handle    myAdvert;
  380.     short    myShort;
  381.     
  382.     copyBufferSize = 512;
  383.     
  384.     myErr = FSpOpenDF( srcDoc, fsRdPerm, &srcRefNum ); 
  385.     if( myErr == noErr ){
  386.         myErr = FSpOpenDF( dstDoc, fsRdWrPerm, &dstRefNum ); 
  387.         if( myErr == noErr ){
  388.             myShort = OpenComponentResFile((Component)self);
  389.             myAdvert = Get1Resource('PICT', kProgressAdvertisement);
  390.             if(myAdvert != nil){
  391.                 DetachResource(myAdvert);
  392.                 SetTranslationAdvertisement(progressRefNum,(PicHandle) myAdvert);
  393.             }
  394.             else {
  395.                 SetTranslationAdvertisement(progressRefNum, nil);
  396.             }
  397.             myErr = CloseComponentResFile(myShort);
  398.             myErr = CopyFork(*srcDoc, srcRefNum, dstRefNum, ©Buffer, copyBufferSize,progressRefNum );
  399.             
  400.         }
  401.     }
  402.     FSClose(srcRefNum);
  403.     FSClose(dstRefNum);
  404.     
  405.     
  406.     return myErr;
  407. }
  408.  
  409. //___________________________________________________________________________________________________________
  410. //
  411. // DoGetTranslatedFilename
  412. //
  413. // 
  414. //
  415. pascal ComponentResult DoGetTranslatedFilename(ComponentInstance     self,
  416.                                                FileType                dstType,
  417.                                                long                    dstTypeHint,
  418.                                                FSSpec*                 theDocument)
  419. {
  420. #pragma unused(self);
  421. #pragma unused(dstType);
  422. #pragma unused(dstTypeHint);
  423. #pragma unused(theDocument);
  424.     Str63 theString;
  425.     FSSpec mySpec;
  426.     OSErr  myErr = noErr;
  427.     short  i = 0;
  428.     
  429.     
  430.     
  431.     BlockMove( theDocument->name, theString, 64);
  432.     theDocument->name[0] = theDocument->name[0] + 3;
  433.     theDocument->name[1] = 'U';
  434.     theDocument->name[2] = 'U';
  435.     theDocument->name[3] = 'P';
  436.  
  437.     BlockMove( theString + 1, theDocument->name + 4, 60);
  438.     
  439.     myErr = FSMakeFSSpec( theDocument->vRefNum, theDocument->parID, theDocument->name, &mySpec);
  440.     //quick and dirty way of naming, some error checking should be done so no illegal characters are used
  441.     while( myErr != fnfErr ){
  442.         theDocument->name[3] = (char)(theDocument->name[3]) + 1;
  443.         myErr = FSMakeFSSpec( theDocument->vRefNum, theDocument->parID, theDocument->name, &mySpec);
  444.     }
  445.     
  446.     if( myErr == fnfErr ){
  447.         myErr = noErr;
  448.     }
  449.     
  450.     return myErr;
  451.     
  452. }
  453. //
  454. //
  455. //  Took this function out of MoreFiles and modified it a bit
  456. //  MoreFiles can be found on the ToolChest edition of the Developer CDs
  457. //
  458. pascal    OSErr    CopyFork(FSSpec srcSpec, short srcRefNum,
  459.                          short dstRefNum,
  460.                          void *copyBufferPtr,
  461.                          long copyBufferSize, TranslationRefNum progressRefNum)
  462. {
  463.     ParamBlockRec srcPB;
  464.     ParamBlockRec dstPB;
  465.     OSErr srcError;
  466.     OSErr dstError;
  467.     Boolean canceled = false;
  468.     short    myPercent = 0;
  469.     short    yourPercent;
  470.     unsigned short  numBlocks;
  471.     long    myBlockSize;
  472.     
  473.     char*    currentCharacter;
  474.     char*    lastCharacter;
  475.  
  476.     if ( (copyBufferPtr == NULL) || (copyBufferSize == 0) )
  477.         return ( paramErr );
  478.     
  479.     srcPB.ioParam.ioRefNum = srcRefNum;
  480.     dstPB.ioParam.ioRefNum = dstRefNum;
  481.  
  482.     // preallocate the destination fork and 
  483.     // ensure the destination fork's EOF is correct after the copy 
  484.     srcError = PBGetEOFSync(&srcPB);
  485.     if ( srcError != noErr )
  486.         return ( srcError );
  487.     dstPB.ioParam.ioMisc = srcPB.ioParam.ioMisc;
  488.     dstError = PBSetEOFSync(&dstPB);
  489.     if ( dstError != noErr )
  490.         return ( dstError );
  491.     
  492.     
  493.     
  494.     // If copyBufferSize is greater than 512 bytes, make it a multiple of 512 bytes 
  495.     // This will make writes on local volumes faster
  496.     
  497.     myBlockSize = ((copyBufferSize >= 512) && (copyBufferSize % 512)) ?
  498.                                (copyBufferSize / 512) * 512 :
  499.                                (copyBufferSize);
  500.     
  501.     //need to know the size of the file to give user feedback 
  502.     //thru the progress dialog box. So here we count the blocks
  503.     
  504.     srcError = CountTheBlocks(srcSpec.vRefNum,
  505.                                        srcSpec.parID,
  506.                                        srcSpec.name, myBlockSize,
  507.                                        &numBlocks);    
  508.     if( srcError == noErr ){
  509.         myPercent = numBlocks;
  510.     }
  511.     else{
  512.         myPercent = 0;
  513.     }
  514.  
  515.     // reset source fork's mark 
  516.     srcPB.ioParam.ioPosMode = fsFromStart;
  517.     srcPB.ioParam.ioPosOffset = 0;
  518.     srcError = PBSetFPosSync(&srcPB);
  519.     if ( srcError != noErr )
  520.         return ( srcError );
  521.  
  522.     // reset destination fork's mark 
  523.     dstPB.ioParam.ioPosMode = fsFromStart;
  524.     dstPB.ioParam.ioPosOffset = 0;
  525.     dstError = PBSetFPosSync(&srcPB);
  526.     if ( dstError != noErr )
  527.         return ( dstError );
  528.  
  529.     // set up fields that won't change in the loop 
  530.     srcPB.ioParam.ioBuffer = (Ptr)copyBufferPtr;
  531.     srcPB.ioParam.ioPosMode = fsAtMark + 0x0020;// fsAtMark + noCacheBit 
  532.     srcPB.ioParam.ioReqCount = myBlockSize;
  533.     
  534.     
  535.  
  536.     dstPB.ioParam.ioBuffer = (Ptr)copyBufferPtr;
  537.     dstPB.ioParam.ioPosMode = fsAtMark + 0x0020;// fsAtMark + noCacheBit 
  538.     yourPercent = 0;
  539.     while ( (srcError == noErr) && (dstError == noErr) )
  540.     {
  541.         srcError = PBReadSync(&srcPB);
  542.         dstPB.ioParam.ioReqCount = srcPB.ioParam.ioActCount;
  543.         
  544.         currentCharacter = (char*)copyBufferPtr;
  545.         lastCharacter = currentCharacter + srcPB.ioParam.ioActCount;
  546.         
  547.         while ((currentCharacter <= lastCharacter) && !canceled)
  548.             {
  549.             // Are we in the lower case ASCII range?
  550.             if (('a' <= *currentCharacter) && (*currentCharacter <= 'z'))
  551.                 {
  552.                 *currentCharacter = (*currentCharacter - ('a' - 'A'));
  553.                 }
  554.             
  555.             
  556.             // Next…
  557.             currentCharacter++;
  558.             
  559.             }
  560.             
  561.         
  562.         dstError = PBWriteSync(&dstPB);
  563.         yourPercent++;
  564.         UpdateTranslationProgress(progressRefNum, ((yourPercent * 100)/myPercent) , &canceled);
  565.         
  566.     }
  567.  
  568.     // make sure there were no errors at the destination 
  569.     if ( dstError != noErr )
  570.         return ( dstError );
  571.  
  572.     // make sure the only error at the source was eofErr 
  573.     if ( srcError != eofErr )
  574.         return ( srcError );
  575.  
  576.     return ( noErr );
  577. }
  578. static    OSErr    CountTheBlocks(short srcVRefNum,
  579.                                        long srcDirID,
  580.                                        ConstStr255Param srcName, long theBlockSize,
  581.                                        unsigned short *numDataBlks)
  582. {
  583.     HParamBlockRec pb;
  584.     OSErr error;
  585.     unsigned short srcDataBlks;
  586.     
  587.     
  588.     // get the size of the file's data resource fork 
  589.     pb.fileParam.ioNamePtr = (StringPtr)srcName;
  590.     pb.fileParam.ioVRefNum = srcVRefNum;
  591.     pb.fileParam.ioFVersNum = 0;
  592.     pb.fileParam.ioDirID = srcDirID;
  593.     pb.fileParam.ioFDirIndex = 0;
  594.     error = PBHGetFInfoSync(&pb);
  595.     if ( error == noErr )
  596.     {
  597.     // get number of 512-byte blocks needed for data fork 
  598.     srcDataBlks = ((unsigned long)pb.fileParam.ioFlLgLen % 512) ?
  599.                   (((unsigned long)pb.fileParam.ioFlLgLen >> 9) + 1) :
  600.                   ((unsigned long)pb.fileParam.ioFlLgLen >> 9);
  601.     }
  602.     
  603.     *numDataBlks = ( srcDataBlks *  512 )/ theBlockSize;
  604.     return ( error );
  605. }